/*
Copyright (c) [2019年5月1日] [吴超]
[MBT_Studio] is licensed under Mulan PSL v2.
You can use this software according to the terms and conditions of the Mulan PSL v2.
You may obtain a copy of Mulan PSL v2 at:
		 http://license.coscl.org.cn/MulanPSL2
THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
See the Mulan PSL v2 for more details.
*/
#include "ui属性栏.h"

#include <面/Surface.h>
#include <UI/布局.h>

#include "A_引擎/引擎.h"

#include "节点视口/ui插座编辑列表.h"
#include "框架/工作区/通用弹出菜单.h"
#include "框架/设置部件窗口.h"


#define DEF_行文本_路径字符分配最大数量 128
#define DEF_行文本_数值字符分配最大数量 10

static float32 g状态栏高度 = 24;
static float32 g_值部件大小 = 20;

static std::stack<C_Widget*> g_间隔填充部件;
static bool 当前开启文本编辑 = false;
static vec2 g节点鼠标局部位置;

static C_Widget*		g属性右键菜单 = nullptr;
static S_鼠标键位映射*	g属性右键菜单快捷键 = nullptr;


static std::set<C_属性栏视口*> g_当前所有属性栏;





void on_属性右键菜单项事件(C_Widget* self, const std::wstring name, uint16 id) {
	if (name == L"插入关键帧") {
		
	}
	else if (name == L"插入单项关键帧") {

	}
	else if (name == L"删除关键帧") {

	}
	else if (name == L"删除单项关键帧") {
		
	}
}

E_事件是否传递 on_打开属性右键菜单事件(C_Widget* self, uint8 状态) {
	f_ui_打开菜单(g属性右键菜单, C_Widget::g_鼠标.gPos);
	return E_事件是否传递::e_事件传递_终止;
}



Inline static C_Widget* f_间隔空部件() {
	C_Widget* w;
	if (g_间隔填充部件.size()) {
		w = g_间隔填充部件.top();
	}
	else {
		w = new C_Widget();
		w->m_是否延展 = { true, true };
	}
	return w;
}


static void f_节点PropUpdate(S_Props& prop) {

}

static bool g是否有手柄在拖动 = false;
static bool on_手柄鼠标进入(C_Widget* self, const S_鼠标& 轮值) {
	C_Widget::g_鼠标样式 = E_鼠标样式::e_鼠标样式_横向双箭头;
	return true;
}

static bool on_手柄鼠标移出(C_Widget* self, const S_鼠标& 轮值) {
	if (!g是否有手柄在拖动) {
		C_Widget::g_鼠标样式 = E_鼠标样式::e_鼠标样式_默认;
	}
	return true;
}

static E_事件是否传递 on_手柄准备拖动(C_Widget* self, const S_鼠标& 鼠标, S_拖放数据& data) {
	C_属性栏* 属性栏 = static_cast<C_属性栏*>(self);
	属性栏->m_View->m_手柄;
	g节点鼠标局部位置 = f_widget_get鼠标局部位置(C_Widget::g_鼠标.gPos, self);

	g是否有手柄在拖动 = true;
	C_Widget::g_鼠标样式 = E_鼠标样式::e_鼠标样式_横向双箭头;
	return E_事件是否传递::e_事件传递_继续;
}

static E_事件是否传递 on_手柄拖动(C_Widget* self, const S_鼠标& 鼠标, S_拖放数据& data) {
	C_属性栏* 属性栏 = static_cast<C_属性栏*>(self);
	
	vec2 pos = f_widget_get鼠标局部位置(C_Widget::g_鼠标.gPos, self->m_父部件);
	pos.x -= g节点鼠标局部位置.x;
	pos.y = 0;

	if (pos.x < 10) pos.x = 10;
	self->f_setPos(pos);
	self->m_父部件->f_setW(pos.x + S_UI主题::ui_拖拽手柄宽度);
	self->m_父部件->m_父部件->m_绘制属性更新 = true;
	
	return E_事件是否传递::e_事件传递_继续;
}


static bool on_手柄结束拖动(C_Widget* self, C_Widget* 拾取的部件, S_拖放数据& data) {
	C_属性栏* 属性栏 = static_cast<C_属性栏*>(self);
	g是否有手柄在拖动 = false;
	C_Widget::g_鼠标样式 = E_鼠标样式::e_鼠标样式_默认;
	return true;
}







static void on_节点树映射_下拉列表变换修改(C_Widget* self) {
	ui_绘制模板_画预设图形& 背景绘制 = *static_cast<ui_绘制模板_画预设图形*>(self->m_绘图模板[0]);
	ui_绘制模板_图标& 图标绘制 = *static_cast<ui_绘制模板_图标*>(self->m_绘图模板[1]);


	S_2D顶点属性 属性;
	属性.m_比例 = { 1,1 };
	属性.m_偏移 = {};
	属性.m_间隔 = S_UI主题::ui_文字间隔;
	属性.m_渐变数量 = 0;
	f_vg_set属性(self->m_画布, 背景绘制.m_属性, 属性);



	背景绘制.f_alloc(4);
	mat3X2 mat;

	mat.row0 = {};
	mat.row1 = self->m_Size;
	mat.row2 = { S_UI主题::ui_面板圆角半径, 0 };
	背景绘制.f_set单色填充(0, mat, S_UI主题::uic_浅灰, S_Widget预设图元::m_圆角矩形);


	auto e = self->f_get更新部件();
	mat.row0 = e.m_W[0]->m_Pos;
	mat.row1 = e.m_W[0]->m_Size;
	mat.row2 = { S_UI主题::ui_面板圆角半径, 0 };
	背景绘制.f_set单色填充(1, mat, e.m_W[0]->m_颜色A, S_Widget预设图元::m_左圆角矩形);

	mat.row0 = e.m_W[2]->m_Pos;
	mat.row1 = e.m_W[2]->m_Size;
	mat.row2 = { S_UI主题::ui_面板圆角半径, 0 };
	背景绘制.f_set单色填充(2, mat, e.m_W[2]->m_颜色A, S_Widget预设图元::m_矩形);

	mat.row0 = e.m_W[3]->m_Pos;
	mat.row1 = e.m_W[3]->m_Size;
	mat.row2 = { S_UI主题::ui_面板圆角半径, 0 };
	背景绘制.f_set单色填充(3, mat, e.m_W[3]->m_颜色A, S_Widget预设图元::m_右圆角矩形);




	图标绘制.f_alloc(3);
	mat.row0 = e.m_W[0]->m_Pos + e.m_W[0]->m_Size * 0.5;
	mat.row1.x = mat.row1.y = e.m_W[0]->m_Size.y * 0.8f;
	mat.row2 = {};
	图标绘制.f_set("import", 0, mat, S_UI主题::uic_深白);

	mat.row0 = e.m_W[2]->m_Pos + e.m_W[2]->m_Size * 0.5;
	mat.row1.x = mat.row1.y = e.m_W[2]->m_Size.y * 0.8f;
	mat.row2 = {};
	图标绘制.f_set("新建文件", 1, mat, S_UI主题::uic_深白);

	mat.row0 = e.m_W[3]->m_Pos + e.m_W[3]->m_Size * 0.5;
	mat.row1.x = mat.row1.y = e.m_W[3]->m_Size.y * 0.8f;
	mat.row2 = {};
	图标绘制.f_set(e.m_W[3]->m_ICO, 2, mat, S_UI主题::uic_深白);

	//const auto& 字体 = f_surface_get字体库(*self->m_UIctx, S_UI主题::ui_默认字体);
}




/*
	枚举部件函数回调区
*/

static void on_枚举项部件更新(C_Widget* 枚举项部件, uint8 e) {
	C_属性栏视口* 属性面板 = dynamic_cast<C_属性栏视口*>(枚举项部件->m_父部件);
}






static bool f_vec部件开启编辑(C_Widget* self, const E_鼠标按钮& 按钮) {
	C_属性栏视口* 属性面板 = dynamic_cast<C_属性栏视口*>(self->m_父部件->m_父部件);
	const auto& 字体 = f_surface_get字体库(*属性面板->m_UIctx, S_UI主题::ui_默认字体);
	//属性面板->m_vec编辑_绘制模板.f_开启编辑(属性面板->m_画布, self, 字体);

	属性面板->m_GPU参数重置 = true;
	return true;
}
static void on_vec编辑框当前输入(C_Widget* self, std::wstring& text) {
	C_属性栏视口* 属性面板 = dynamic_cast<C_属性栏视口*>(self->m_父部件->m_父部件);
	const auto& 字体 = f_surface_get字体库(*属性面板->m_UIctx, S_UI主题::ui_默认字体);
	//属性面板->m_vec编辑_绘制模板.f_当前输入(属性面板->m_画布, *self, 字体, text);

	属性面板->m_GPU参数重置 = true;
}
static void f_vec3_行编辑框变换修改(C_Widget* self, mat3X2** t, uint16 num) {
	C_属性栏视口* 属性面板 = dynamic_cast<C_属性栏视口*>(self->m_父部件->m_父部件);
	C_文本框* editBox = dynamic_cast<C_文本框*>(self);
	
	//属性面板->m_vec编辑_绘制模板.f_GPU参数修改(属性面板->m_画布, *editBox);
	
}



static void on_路径编辑框绘制调整回调(C_Widget* r, uint32 调整部分) {

}



C_工具视口部件容器::C_工具视口部件容器() : m_准备废弃_组件内文本(20), m_名称标签(20) {
	m_分组框使用计数 = 0;
	m_标签使用计数 = 0;
	m_按钮使用计数 = 0;
	m_开关使用计数 = 0;
	//m_单色边面使用计数 = 0;
	m_vec2使用计数 = 0;
	m_vecf使用计数 = 0;
	m_vec4使用计数 = 0;
	m_插座列表框使用计数 = 0;
	m_拾色器使用计数 = 0;
	m_曲线采样器使用计数 = 0;

	m_vec全部分量使用计数 = 0;


	
}



C_属性栏视口::C_属性栏视口(S_UI创建环境& ctx) : C_Widget(&ctx) {
	f_setSize({128, 20});
	
	mf_外部部件更新 = 0;
	m_外部绑定部件 = 0;
	m_滚动量 = 0;

	m_布局方向 = E_方向::e_纵向;

	g_当前所有属性栏.insert(this);
}

C_属性栏视口::~C_属性栏视口() {
	g_当前所有属性栏.erase(this);

	for (auto& e : m_属性) {
		//if (!e.m_私有) f_prop_Release(e);
	}
	m_属性.clear();
}


void C_属性栏视口::f_打开() {
	g_当前所有属性栏;
}

void C_属性栏视口::f_关闭() {
	g_当前所有属性栏;
}


void C_属性栏视口::f_重新构建组件(std::vector<S_Props>& newProp) {
	C_Widget* w = nullptr;
	uint32 i = 0;

	for (auto& e : newProp) {
		//continue;
		switch (e.m_Type) {
		case E_值类型::e_Type_None: {
			w = f_间隔空部件();
			break;
		}

		case E_值类型::e_Type_Str: {
			
			if (m_字符部件.size() > m_字符使用计数) {
				w = m_字符部件[m_字符使用计数];
			}
			else {
				w = f_ui_创建标签(*m_UIctx);
				m_字符部件.push_back(w);
			}
			e.m_UI->m_部件 = w;
			f_ui_绑定标签属性(w, e);

			++m_字符使用计数;
			++m_标签使用计数;
			break;
		}

		case E_值类型::e_Type_LineText: {
			
			if (m_行文本编辑框部件.size() > m_行文本编辑框使用计数) {
				w = m_行文本编辑框部件[m_行文本编辑框使用计数];
			}
			else {
				w = f_ui_创建行文本编辑框(*m_UIctx);
				m_行文本编辑框部件.push_back(w);
			}
			e.m_UI->m_部件 = w;
			f_ui_bind行编辑框属性(w, e);

			++m_行文本编辑框使用计数;
			//++m_标签使用计数;
			break;
		}

		case E_值类型::e_Type_路径: {
			if (m_路径部件.size() > m_路径使用计数) {
				w = m_路径部件[m_路径使用计数];
			}
			else {
				w = f_ui_创建路径编辑框(*m_UIctx, S_框架::g_ui文件对话框, on_路径编辑框绘制调整回调);
				m_路径部件.push_back(w);
			}
			e.m_UI->m_部件 = w;
			f_ui_bind路径编辑框属性(w, &e);

			++m_路径使用计数;
			//++m_标签使用计数;


			//w->m_GPU文本变换内存偏移 = m_组件行文本变换绘制GPU计数;
			//w->m_GPU文本字符内存偏移 = m_组件行文本字符绘制GPU计数;

			//++m_组件行文本变换绘制GPU计数;
			//m_组件行文本字符绘制GPU计数 += DEF_行文本_路径字符分配最大数量;

			break;
		}

		case E_值类型::e_Type_Operator: {
			if (m_按钮部件.size() > m_按钮使用计数) {
				w = m_按钮部件[m_按钮使用计数];
				
			}
			else {
				w = f_ui_创建按钮(m_UIctx, &e);
				m_按钮部件.push_back(w);
			}
			e.m_UI->m_部件 = w;
			f_ui_设置按钮操作符(w, e);

			++m_按钮使用计数;
			//++m_标签使用计数;
			break;
		}

		case E_值类型::e_Type_Enum: {
			if (m_枚举部件.size() > m_枚举使用计数) {
				w = m_枚举部件[m_枚举使用计数];
				
			}
			else {
				w = f_ui_创建枚举选择框(*m_UIctx, e, E_方向::e_横向);
				m_枚举部件.push_back(w);
			}
			e.m_UI->m_部件 = w;
			f_ui_bind枚举部件属性(w, e);
			w->m_实例ID = m_枚举使用计数;

			++m_枚举使用计数;
			//++m_标签使用计数;
			break;
		}

		case E_值类型::e_Type_Bool:
			if (m_开关部件.size() > m_单值ui使用计数) {
				w = m_开关部件[m_单值ui使用计数];
			}
			else {
				w = f_ui_创建bool值编辑框(*m_UIctx, e);
				m_开关部件.push_back(w);
			}
			f_ui_设置bool值编辑框引用值(w, e);
			++m_单值ui使用计数;
			++m_标签使用计数;
			break;


		case E_值类型::e_Type_I8:
		case E_值类型::e_Type_UI8:
		case E_值类型::e_Type_I32:
		case E_值类型::e_Type_UI32:
		case E_值类型::e_Type_F32:
		case E_值类型::e_Type_UI64:
			if (m_单数值_部件.size() > m_单值ui使用计数) {
				w = m_单数值_部件[m_单值ui使用计数];
			}
			else {
				w = f_ui_创建数值编辑框(*m_UIctx, e);
				m_单数值_部件.push_back(w);
			}
			e.m_UI->m_部件 = w;
			f_ui_设置数值编辑框引用值(w, e);

			f_ui_注册鼠标快捷键(w, (S_键位映射*)g属性右键菜单快捷键);
			w->m_实例ID = m_单值ui使用计数;
			++m_单值ui使用计数;
			++m_标签使用计数;

			break;

		case E_值类型::e_Type_iVec2:
		case E_值类型::e_Type_Vec2:
		case E_值类型::e_Type_uVec2:
			if (m_vec2_部件.size() > m_vec2使用计数) {
				w = m_vec2_部件[m_vec2使用计数];
			}
			else {
				w = f_ui_创建vec编辑框(*m_UIctx, e);
				w->m_间隔宽度 = 1;
				m_vec2_部件.push_back(w);
			}
			e.m_UI->m_部件 = w;
			f_ui_设置vec编辑框引用值(w, e);
			f_ui_setVec布局方向(w, m_布局方向);

			w->m_实例ID = m_vec2使用计数;

			
			++m_vec2使用计数;
			++m_标签使用计数;
			break;


		case E_值类型::e_Type_iVec3:
		case E_值类型::e_Type_uVec3:
		case E_值类型::e_Type_Vec3:
		case E_值类型::e_Type_Vec4:
			if (m_vecf_部件.size() > m_vecf使用计数) {
				w = m_vecf_部件[m_vecf使用计数];
			}
			else {
				w = f_ui_创建vec编辑框(*m_UIctx, e);
				m_vecf_部件.push_back(w);
			}
			e.m_UI->m_部件 = w;
			f_ui_设置vec编辑框引用值(w, e);

			w->m_实例ID = m_vecf使用计数;

			
			++m_vecf使用计数;
			++m_标签使用计数;
			break;


		case E_值类型::e_Type_UI32_FlagBits: 
		case E_值类型::e_Type_Bool_1D: {
			if (m_多选框_部件.size() > m_多选框使用计数) {
				w = m_多选框_部件[m_多选框使用计数];
			}
			else {
				w = f_ui_创建多选框(*m_UIctx, e, S_InputKey::e_KEY_左SHIFT);
			}
			e.m_UI->m_部件 = w;
			f_ui_bind多选框属性(w, e, m_布局方向);
			++m_多选框使用计数;
			break;
		}

		case E_值类型::e_Type_MapPtr_Array1D: {
			if (m_列表框_部件.size() > m_列表框使用计数) {
				w = m_列表框_部件[m_列表框使用计数];
			}
			else {
				w = f_ui_创建下拉列表(*m_UIctx, true, !m_布局方向);
			}
			e.m_UI->m_部件 = w;
			w->mf_变换修改 = on_节点树映射_下拉列表变换修改;
			f_ui_绑定下拉列表属性(w, e);

			++m_列表框使用计数;
			break;
		}
		case E_值类型::e_Type_映射引用_2D: {
			if (m_超级列表编辑框_组件.size() > m_超级列表编辑框计数) {
				w = m_超级列表编辑框_组件[m_超级列表编辑框计数];
			}
			else {
				w = f_ui_创建超级列表编辑框(*m_UIctx, true);
			}
			e.m_UI->m_部件 = w;
			//w->mf_变换修改 = on_节点树映射_下拉列表变换修改;
			f_ui_绑定超级列表编辑框属性(w, e);

			++m_超级列表编辑框计数;
			break;
		}

		case E_值类型::e_Type_Object_1D:
		case E_值类型::e_Type_PropContainer:
			if (m_插座列表框_部件.size() > m_插座列表框使用计数) {
				w = m_插座列表框_部件[m_插座列表框使用计数];
			} else {
				w = f_创建插座编辑列表(*m_UIctx);
				m_插座列表框_部件.emplace_back(w);
			}
			e.m_UI->m_部件 = w;
			f_插座编辑列表绑定属性数据(w, e);
			++m_插座列表框使用计数;
			break;



		case E_值类型::e_Type_RGB:
		case E_值类型::e_Type_纹理:
			if (m_拾色器_部件.size() > m_拾色器使用计数) {
				w = m_拾色器_部件[m_拾色器使用计数];
			}
			else {
				w = f_ui_创建拾色器(*m_UIctx, e);
				m_拾色器_部件.push_back(w);
			}
			f_ui_拾色器绑定属性(w, e);
			++m_拾色器使用计数;
			//++m_标签使用计数;
			break;

		case E_值类型::e_Type_TexProp:
			if (m_纹理_部件.size() > m_纹理使用计数) {
				w = m_纹理_部件[m_纹理使用计数];
			}
			else {
				w = f_ui_创建过程纹理图像框(*m_UIctx);
				m_纹理_部件.push_back(w);
			}
			f_ui_bind图像框纹理属性(w, e);
			++m_纹理使用计数;
			//++m_标签使用计数;
			break;

		case E_值类型::e_Type_2D曲线: {
			if (m_曲线采样器_部件.size() > m_曲线采样器使用计数) {
				w = m_曲线采样器_部件[m_曲线采样器使用计数];
			}
			else {
				w = f_ui_创建曲线采样器(*m_UIctx);
				m_曲线采样器_部件.push_back(w);
			}
			f_ui_曲线采样器绑定属性数据(w, e);
			++m_曲线采样器使用计数;
			break;
		}

		/*case E_值类型::e_Type_Object_1D: {
			if (m_物体组_部件.size() > m_物体组使用计数) {
				w = m_物体组_部件[m_物体组使用计数];
			}
			else {
				w = f_ui_创建曲线采样器(*m_UIctx);
				m_物体组_部件.push_back(w);
			}
			f_ui_曲线采样器绑定属性数据(w, e);
			++m_物体组使用计数;
			break;
		}*/

		case E_值类型::e_Type_Node: {

			break;
		}

		case E_值类型::e_Type_LayoutList: {
			if (m_分组框.size() > m_分组框使用计数) {
				w = m_分组框[m_分组框使用计数];
			}
			else {
				w = new C_Widget;
				m_分组框.push_back(w);
			}

			w->m_实例ID = m_分组框使用计数;
			++m_分组框使用计数;
			
			w->m_TypeName = f_WStringToString(e.m_Name);
			e.m_UI->m_部件 = w;
			++i;
			f_添加子组件(w);

			auto& container = f_prop_Container(e);
			f_重新构建组件(container.m_Item);
			continue;
		}
		}



		f_widget_属性链接组件(e, {w});
		w->m_TypeName = f_WStringToString(e.m_Name);
		e.m_UI->m_部件 = w;
		//if (e.m_UI->m_LinkWidget) {
		//	e.m_UI->m_LinkWidget->insert(w);
		//}
		++i;

		f_添加子组件(w);
	}
}

void C_属性栏视口::f_构建属性部件(std::vector<S_Props>& newProp) {
	for (auto& e : m_属性) {
		if (!e.m_私有) f_prop_Release(e);
	}
	m_属性.clear();
	m_属性 = newProp;

	for (auto& e : m_属性) {
		f_widget_属性断开组件(e, m_分组框);
		f_widget_属性断开组件(e, m_字符部件);
		f_widget_属性断开组件(e, m_路径部件);
		f_widget_属性断开组件(e, m_单数值_部件);
		f_widget_属性断开组件(e, m_vec2_部件);
		f_widget_属性断开组件(e, m_vecf_部件);
		f_widget_属性断开组件(e, m_vec4_部件);
		f_widget_属性断开组件(e, m_多选框_部件);
		f_widget_属性断开组件(e, m_列表框_部件);
		f_widget_属性断开组件(e, m_插座列表框_部件);
		f_widget_属性断开组件(e, m_拾色器_部件);
		f_widget_属性断开组件(e, m_曲线采样器_部件);
		f_widget_属性断开组件(e, m_纹理_部件);
		f_widget_属性断开组件(e, m_物体组_部件);
		f_widget_属性断开组件(e, m_超级列表编辑框_组件);
		f_widget_属性断开组件(e, m_行文本编辑框部件);
	}


	m_子组件.clear();

	


	m_标签使用计数 = 0;

	m_分组框使用计数 = 0;
	m_字符使用计数 = 0;
	m_枚举使用计数 = 0;
	m_按钮使用计数 = 0;
	m_开关使用计数 = 0;
	m_vec2使用计数 = 0;
	m_uVec2使用计数 = 0;
	m_vecf使用计数 = 0;
	m_路径使用计数 = 0;
	m_多选框使用计数 = 0;
	m_列表框使用计数 = 0;
	m_插座列表框使用计数 = 0;
	m_拾色器使用计数 = 0;
	m_曲线采样器使用计数 = 0;
	m_纹理使用计数 = 0;
	m_超级列表编辑框计数 = 0;

	m_单值ui使用计数 = 0;
	//m_组件行文本变换绘制GPU计数 = 0;
	//m_组件行文本字符绘制GPU计数 = 0;
	m_行文本编辑框使用计数 = 0;

	
	f_重新构建组件(m_属性);

	m_绘制属性更新 = true;
}

void C_属性栏视口::f_切换方向(E_方向 方向) {
	m_布局方向 = 方向;
}

static float32 g两边间隙 = 4;
static float32 g上下间隙 = 20;
static float32 g左边推进宽度 = 70;



static void f_属性栏标签GPU参数修改(C_属性栏视口* box, S_Props& e, uint32& i, const S_Font& 字体) {
	if(!e.m_UI->m_部件) return;

	switch (e.m_Type) {
	case E_值类型::e_Type_Str:
	case E_值类型::e_Type_Bool:

	case E_值类型::e_Type_I8:
	case E_值类型::e_Type_UI8:
	case E_值类型::e_Type_I32:
	case E_值类型::e_Type_UI32:
	case E_值类型::e_Type_F32:
	case E_值类型::e_Type_UI64:
	
	case E_值类型::e_Type_iVec2:
	case E_值类型::e_Type_Vec2:
	case E_值类型::e_Type_uVec2:
	case E_值类型::e_Type_uVec3:
	case E_值类型::e_Type_Vec3:
	case E_值类型::e_Type_iVec3:
	
	//case E_值类型::e_Type_路径:
	//case E_值类型::e_Type_TexProp:
	//case E_值类型::e_Type_LineText:
	//case E_值类型::e_Type_Node:
	//case E_值类型::e_Type_Enum:
	//case E_值类型::e_Type_纹理:
		box->m_标签绘制.f_绘制文本({ {0, e.m_UI->m_部件->m_Pos.y + g两边间隙}, {g左边推进宽度 - g两边间隙, g_值部件大小 } }, S_UI主题::uic_文字颜色, i, e.m_Name, E_对齐方式::e_右对齐);
		//box->m_标签绘制.f_绘制文本({ {0, e.m_UI->m_部件->m_Pos.y + g两边间隙}, {g左边推进宽度 - g两边间隙, g_值部件大小 } }, S_UI主题::uic_文字颜色, i, L"", E_对齐方式::e_右对齐);
		++i;
		break;
	}
	

	switch (e.m_Type) {
		case E_值类型::e_Type_LayoutList: {
			auto& container = f_prop_Container(e);
			for (auto& se : container.m_Item) {
				f_属性栏标签GPU参数修改(box, se, i, 字体);
			}
			break;
		}
	}

}





static void on_属性栏Draw(C_Widget* self, S_2D画布* 画布) {
	C_属性栏* box = dynamic_cast<C_属性栏*>(self);
	box->m_View->m_背景绘制.m_属性 = f_vg_gen属性(画布);
	
	S_凸边图元 图元 = {};
	图元.属性 = f_vg_get属性指针(画布, box->m_View->m_背景绘制.m_属性);

	box->m_View->m_背景绘制.f_Draw(画布, 图元, E_笔刷类型::e_单色填充);

	auto 字体 = f_surface_get字体(*self->m_UIctx, S_UI主题::ui_默认字体);
	box->m_View->m_标签绘制.f_Draw(画布, &字体, box->m_View->m_背景绘制.m_属性);

}

static void on_属性栏变换修改(struct C_Widget* self) {
	C_属性栏* box = dynamic_cast<C_属性栏*>(self);
	
	uint32 num = box->m_View->m_分组框使用计数;
	box->m_View->m_背景绘制.f_alloc(2 + num);
	box->m_View->m_标签绘制.f_alloc(box->m_View->m_标签使用计数, 10);


	mat3X2 mat;
	mat.row0 = box->m_View->m_手柄->m_Pos;
	mat.row1 = box->m_View->m_手柄->m_Size;
	mat.row2 = { S_UI主题::ui_面板圆角半径 * 2, 0 };
	box->m_View->m_背景绘制.f_set单色填充(1, mat, S_UI主题::uic_面板背景 + S_RGBA8UI{10,10,10,0}, S_Widget预设图元::m_矩形);

	mat.row0 = {};
	mat.row1 = box->m_Size;
	mat.row2 = { S_UI主题::ui_面板圆角半径 * 2, 0 };
	box->m_View->m_背景绘制.f_set单色填充(0, mat, S_UI主题::uic_面板背景, S_Widget预设图元::m_矩形);


	auto* group_box = box->m_View->m_分组框.data();
	for (uint32 i = 0; i < num; ++i) {
		mat.row0 = group_box[i]->m_Pos;
		mat.row1 = group_box[i]->m_Size;

		box->m_View->m_背景绘制.f_set单色填充(i+2, mat, S_UI主题::uic_面板背景 + S_RGBA8UI{10,10,10,0}, S_Widget预设图元::m_圆角矩形);
	}

	const auto& 字体 = f_surface_get字体库(*self->m_UIctx, S_UI主题::ui_默认字体);
	uint32 i = 0;
	for (auto& e : box->m_View->m_属性) {
		f_属性栏标签GPU参数修改(box->m_View, e, i, 字体);
	}
	
}


static void on_属性栏单个组件布局(C_属性栏视口* 属性栏, vec2& pos, S_Props& e, float32 推进, float32 宽度) {
	uint8 矢量部件分量数量 = 0;
	
	推进 += g两边间隙;
	宽度 -= (g两边间隙 * 2) + 10;

	vec2 推进左边 = pos;
	推进左边.x = 推进 + g左边推进宽度;
	if(!e.m_UI->m_部件) return;

	switch (e.m_Type) {
	case E_值类型::e_Type_LayoutList: {
		float32 高度 = pos.y;
		e.m_UI->m_部件->f_setPos(pos);

		pos.y += g上下间隙;
		auto& container = f_prop_Container(e);
		for (auto& se : container.m_Item) {
			on_属性栏单个组件布局(属性栏, pos, se, 推进, 宽度);
		}

		高度 = pos.y - 高度;
		e.m_UI->m_部件->f_setSize({ 宽度, 高度 });
		break;
	}
	case E_值类型::e_Type_Operator:
		e.m_UI->m_部件->f_setPos(推进左边);
		e.m_UI->m_部件->f_setSize({ 宽度, g_值部件大小 });
		break;

	case E_值类型::e_Type_Enum: {
		S_PropValueEnum 枚举 = *((S_PropValueEnum*)e.m_Value);

		vec2 枚举部件大小 = vec2{ 宽度 - g左边推进宽度, g_值部件大小 };
		if (枚举.m_展开) {
			f_ui_set枚举选择框(e.m_UI->m_部件, E_方向::e_纵向);
		}
		else {
			f_ui_set枚举选择框(e.m_UI->m_部件, E_方向::e_纵向);
		}

		枚举部件大小.y *= e.m_值元素个数;

		e.m_UI->m_部件->f_setPos(推进左边);
		e.m_UI->m_部件->f_setSize(枚举部件大小);

		属性栏->m_枚举部件元素个数 += e.m_值元素个数;
		pos.y += 枚举部件大小.y;
		break;
	}

	case E_值类型::e_Type_Node:
	case E_值类型::e_Type_Str:
	case E_值类型::e_Type_LineText:
	case E_值类型::e_Type_路径: {
		e.m_UI->m_部件->f_setPos(推进左边);
		e.m_UI->m_部件->f_setSize({ 宽度 - g左边推进宽度, g_值部件大小 });
		break;
	}

	case E_值类型::e_Type_Bool:
		e.m_UI->m_部件->f_setPos(推进左边);
		e.m_UI->m_部件->f_setSize({ g_值部件大小, g_值部件大小 });
		break;

	case E_值类型::e_Type_I16:
	case E_值类型::e_Type_I32:
	case E_值类型::e_Type_I64:
	case E_值类型::e_Type_UI64:
	case E_值类型::e_Type_F32:
	case E_值类型::e_Type_F64:
		e.m_UI->m_部件->f_setPos(推进左边);
		e.m_UI->m_部件->f_setSize({ 宽度 - g左边推进宽度, g_值部件大小 });
		break;

	case E_值类型::e_Type_uVec2:
	case E_值类型::e_Type_iVec2:
	case E_值类型::e_Type_Vec2: {
		矢量部件分量数量 = 2;
		goto To_矢量部件布局;
		break;
	}
	case E_值类型::e_Type_iVec3:
	case E_值类型::e_Type_uVec3:
	case E_值类型::e_Type_Vec3:
		矢量部件分量数量 = 3;
		goto To_矢量部件布局;
		break;

	case E_值类型::e_Type_Vec4:
		矢量部件分量数量 = 4;
		goto To_矢量部件布局;
		break;

	case E_值类型::e_Type_RGB:
	case E_值类型::e_Type_纹理:
		e.m_UI->m_部件->f_setPos(推进左边);
		e.m_UI->m_部件->f_setSize({ 宽度 - 推进左边.x, g_值部件大小 });
		break;

	case E_值类型::e_Type_TexProp:
		e.m_UI->m_部件->f_setPos(pos);
		e.m_UI->m_部件->f_setSize({ 宽度, 200 });
		pos.y += 200 + S_UI主题::ui_面板圆角半径;
		return;

	case E_值类型::e_Type_2D曲线:
		e.m_UI->m_部件->f_setPos(pos);
		e.m_UI->m_部件->f_setSize({ 宽度 - g两边间隙, 160 });
		pos.y += 160 + S_UI主题::ui_面板圆角半径;
		return;

	case E_值类型::e_Type_UI32_FlagBits: {
		e.m_UI->m_部件->f_setPos(pos);
		e.m_UI->m_部件->f_setSize({ 宽度 - g两边间隙, 90 });
		pos.y += 90 + S_UI主题::ui_面板圆角半径;
		break;
	}
	case E_值类型::e_Type_Bool_1D: {
		e.m_UI->m_部件->f_setPos(pos);
		e.m_UI->m_部件->f_setSize({ 宽度, e.m_值元素个数 * 20 + S_UI主题::ui_面板圆角半径 });
		pos.y += e.m_UI->m_部件->m_Size.y;
		break;
	}

	case E_值类型::e_Type_映射引用_2D:
	case E_值类型::e_Type_MapPtr_Array1D: {
		e.m_UI->m_部件->f_setPos(pos);
		e.m_UI->m_部件->f_setSize({ 宽度, g状态栏高度 });
		pos.y += g状态栏高度;
		break;
	}

	case E_值类型::e_Type_Object_1D:
	case E_值类型::e_Type_PropContainer: {
		//插座列表
		e.m_UI->m_部件->f_setPos(pos);
		e.m_UI->m_部件->f_setSize({ 宽度, g_值部件大小*30 });
		pos.y += g_值部件大小 * 30;
		break;
	}

	default:
		e.m_UI->m_部件->f_setPos(推进左边);
		e.m_UI->m_部件->f_setSize({ 宽度 - g左边推进宽度, g_值部件大小 });
		break;
	}

	pos.y += g上下间隙 + S_UI主题::ui_面板圆角半径;
	

	return;

To_矢量部件布局:
	e.m_UI->m_部件->f_setPos(推进左边);
	e.m_UI->m_部件->f_setSize({ 宽度 - g左边推进宽度, g_值部件大小 * 矢量部件分量数量 });
	e.m_UI->m_部件->m_间隔宽度 = 1;

	pos.y += g_值部件大小 * 矢量部件分量数量;
	pos.y += g上下间隙 + S_UI主题::ui_面板圆角半径;
	//属性栏->m_vec全部分量使用计数 += 矢量部件分量数量;
	
}

static void on_属性栏布局(C_Widget* self, C_Widget** w, uint32 num) {
	C_属性栏* 属性栏 = dynamic_cast<C_属性栏*>(self);
	
	float32 左边 = 0;
	vec2 pos = { 左边, 属性栏->m_View->m_滚动量 + 10 };
	

	
	//float32 宽度 = self->m_Size.x - S_UI主题::ui_滚动条厚度;
	float32 宽度 = 属性栏->m_View->m_手柄->f_getPos().x ;
	//float32 宽度 = 属性栏->m_View->m_Size.x;
	C_Widget* 当前父组件 = nullptr;
	for (auto& e : 属性栏->m_View->m_属性) {
		on_属性栏单个组件布局(属性栏->m_View, pos, e, 0, 宽度);
	}


	vec2 size = self->m_Size;
	size.x = S_UI主题::ui_拖拽手柄宽度;
	//属性栏->m_View->m_手柄->f_getPos();
	属性栏->m_View->m_手柄->f_setSize(size);


	//C_属性栏* 属性栏根面板 = dynamic_cast<C_属性栏*>(属性栏->m_父部件->m_父部件);
	float32 总高度 = pos.y + S_UI主题::ui_滚动条厚度 * 2 - 属性栏->m_View->m_滚动量;

	
	属性栏->m_View->f_setSize({ 宽度, 总高度 });

	属性栏->m_滚动窗口->f_setSize({ 宽度, self->m_Size.y });
	属性栏->f_setW(宽度 + S_UI主题::ui_滚动条厚度);
	
}

static bool on_属性栏内视口滚动(C_Widget* self, const S_鼠标& 鼠标) {
	C_属性栏* s = dynamic_cast<C_属性栏*>(self);
	
	float32 父组件大小 = self->m_Size.y;
	
	float32 步进 = s->m_View->m_滚动量 + C_Widget::g_鼠标.lZ * 40;
	self->m_绘制属性更新 = true;

	if (s->m_View->m_Size.y + 步进 <= 父组件大小) {
		步进 = (父组件大小 - s->m_View->m_Size.y);
		//return true;
	}
	if (步进 > 0) {
		s->m_View->m_滚动量 = 0;
		return true;
	}

	s->m_View->m_滚动量 = 步进;
	
	return true;
}


C_属性栏::C_属性栏(S_UI创建环境& ctx) : C_Widget(&ctx) {
	
	
	m_View = new C_属性栏视口(ctx);
	m_View->f_setSize({ 200, 20 });
	m_View->m_手柄 = new C_Widget(&ctx);
	m_View->m_手柄->mf_开始拖拽 = on_手柄准备拖动;
	m_View->m_手柄->mf_拖拽 = on_手柄拖动;
	m_View->m_手柄->mf_结束拖拽 = on_手柄结束拖动;
	m_View->m_手柄->f_setPos({ 200 - S_UI主题::ui_拖拽手柄宽度,0 });

	m_View->m_布局方向 = E_方向::e_纵向;

	m_View->m_手柄->mf_鼠标进入 = on_手柄鼠标进入;
	m_View->m_手柄->mf_鼠标离开 = on_手柄鼠标移出;



	m_滚动窗口 = f_ui_创建滚动框(ctx, false, true, m_View);
	m_滚动窗口->f_setSize({ 256, 20 });
	m_滚动窗口->mf_鼠标滚轮 = nullptr;
	
	mf_DrawFun = on_属性栏Draw;
	mf_布局Fun = on_属性栏布局;
	mf_变换修改 = on_属性栏变换修改;
	mf_鼠标滚轮 = on_属性栏内视口滚动;
	//m_动态高度 = 128;
	f_setSize({ 20, 20 });

	{
		f_添加子组件(m_滚动窗口);
		f_添加子组件(m_View->m_手柄);

		{
			m_View->f_切换方向(E_方向::e_纵向);
		}
	}
	
}

void C_属性栏::f_打开() {
}

void C_属性栏::f_关闭() {
}

void C_属性栏::f_设置宽度(float32 w) {
	m_View->m_手柄->f_setX(w);
	f_setX(w + S_UI主题::ui_拖拽手柄宽度);
}

void C_属性栏::f_构建属性部件(std::vector<S_Props>& newProp) {
	//return;
	m_View->f_构建属性部件(newProp);
	
	m_绘制属性更新 = true;
	m_GPU参数重置 = true;
}


C_属性栏* f_创建属性边栏(S_UI创建环境& ctx) {
	C_属性栏* 属性栏 = new C_属性栏(ctx);
	return 属性栏;
}




void f_属性栏_初始化(S_UI创建环境& ctx) {
	g属性右键菜单 = f_通用菜单_属性值右键菜单(ctx, on_属性右键菜单项事件);

	g属性右键菜单快捷键 = f_widget_init_鼠标键位映射();
	g属性右键菜单快捷键->event = on_打开属性右键菜单事件;
	g属性右键菜单快捷键->鼠标按键[0] = E_Input_鼠标按键::e_右键;
	g属性右键菜单快捷键->鼠标状态[0] = DEF_按键状态_按下;
	C_键位映射配置::f_添加全局操作键位((S_键位映射*)g属性右键菜单快捷键, L"数值组件弹出菜单");
}

void f_属性栏_清理() {
	delete g属性右键菜单;
}



















void on_状态栏布局(C_Widget* self, C_Widget** w, uint32 num) {
	C_状态条* 状态栏 = dynamic_cast<C_状态条*>(self);

	状态栏->m_View->m_vec全部分量使用计数 = 0;
	状态栏->m_View->m_枚举部件元素个数 = 0;
	//状态栏->m_View->m_单色边面使用计数 = 0;
	状态栏->m_View->m_路径使用计数 = 0;

	
	vec2 size = self->m_Size;
	
	size.y -= S_UI主题::ui_拖拽手柄宽度 * 0.5f;
	状态栏->m_View->f_setSize(size);
	//size.y -= S_UI主题::ui_拖拽手柄宽度;

	vec2 pos = { 5, S_UI主题::ui_拖拽手柄宽度*0.5f };
	
	auto* p = 状态栏->m_View->m_属性.data();
	uint32 pNum = 状态栏->m_View->m_属性.size();


	//状态栏->m_枚举部件元素个数 = 0;
	状态栏->m_View->m_按钮开关绘制数量 = 0;

	for (uint32 i = 0; i < pNum; ++i) {
		auto& e = p[i];
		uint8 矢量部件分量数量 = 0;
		if(!p[i].m_UI->m_部件) continue;

		switch (p[i].m_Type) {
		case E_值类型::e_Type_None:
			//p[i].m_UI->m_部件 = f_间隔空部件();
			break;

		case E_值类型::e_Type_LayoutList: {

			break;
		}
		case E_值类型::e_Type_Operator:
			p[i].m_UI->m_部件->f_setSize({ 60, g状态栏高度 });
			p[i].m_UI->m_部件->m_颜色A = S_UI主题::uic_按钮;
			++(状态栏->m_View->m_按钮开关绘制数量);
			break;

		case E_值类型::e_Type_Enum: {
			S_PropValueEnum 枚举 = *((S_PropValueEnum*)p[i].m_Value);

			vec2 枚举部件大小 = vec2{ g状态栏高度, g状态栏高度 } - S_UI主题::ui_拖拽手柄宽度 * 0.5f;
			if (枚举.m_展开) {
				枚举部件大小.x *= p[i].m_值元素个数;

				//p[i].m_UI->m_部件->m_GPU内存偏移 = 状态栏->m_View->m_枚举部件元素个数;
				状态栏->m_View->m_枚举部件元素个数 += p[i].m_值元素个数;
			}
			else {
				枚举部件大小.x = 200;

				//(p[i].m_UI->m_部件->m_GPU内存偏移) = 状态栏->m_View->m_枚举部件元素个数;
				++(状态栏->m_View->m_枚举部件元素个数);
			}
			f_ui_set枚举选择框图标和文字是否绘制(p[i].m_UI->m_部件, true, false);
			p[i].m_UI->m_部件->f_setSize(枚举部件大小);
			
			break;
		}
		case E_值类型::e_Type_Bool:
			//p[i].m_部件->f_setLoc({ 5, pos.y });
			p[i].m_UI->m_部件->f_setSize({ 18, 18 });
			++(状态栏->m_View->m_按钮开关绘制数量);
			break;

		case E_值类型::e_Type_I16:
		case E_值类型::e_Type_I32:
		case E_值类型::e_Type_I64:
		case E_值类型::e_Type_F32:
		case E_值类型::e_Type_F64:
			p[i].m_UI->m_部件->f_setSize({ 100, g状态栏高度 });
			//if (p[i].m_UI->m_LinkWidget) {
			//	for (auto& e : *p[i].m_UI->m_LinkWidget) {
			//		e->f_setSize({ 100, g状态栏高度 });
			//	}
			//}
			break;


		case E_值类型::e_Type_uVec2:
		case E_值类型::e_Type_iVec2:
			p[i].m_UI->m_部件->f_setSize({150, g状态栏高度 });
			矢量部件分量数量 = 2;
			goto To_矢量部件布局;
			break;
		case E_值类型::e_Type_iVec3:
		case E_值类型::e_Type_uVec3:
		case E_值类型::e_Type_Vec3:
			矢量部件分量数量 = 3;
			goto To_矢量部件布局;
			break;


		case E_值类型::e_Type_Bool_1D: {
			p[i].m_UI->m_部件->f_setSize({p[i].m_值元素个数 * g状态栏高度, g状态栏高度 });
			break;
		}

		case E_值类型::e_Type_映射引用_2D:
		case E_值类型::e_Type_MapPtr_Array1D: {
			p[i].m_UI->m_部件->f_setSize({ 200, g状态栏高度 });
			break;
		}

		default:
			//p[i].m_部件->f_setLoc(pos);
			//p[i].m_部件->f_setSize({ self->m_Size.x - 100 - S_UI主题::ui_滚动条厚度 * 2, 18 });
			break;
		}
		//p[i]


	//	continue;
	To_矢量部件布局:
		//e.m_UI->m_部件->m_GPU内存偏移 = 状态栏->m_View->m_vec全部分量使用计数;
		状态栏->m_View->m_vec全部分量使用计数 += 矢量部件分量数量;
		//状态栏->m_View->m_vec绘制模板.f_Layout(e.m_部件);
	}
	

	auto e = 状态栏->m_View->f_get更新部件();
	size = 状态栏->m_View->m_Size;
	size.y -= S_UI主题::ui_拖拽手柄宽度*0.5;
	if(e.m_Num) f_HBOX布局(pos, size, e.m_W, e.m_Num);

}




static void on_状态栏Draw(C_Widget* self, S_2D画布* 画布) {
	C_状态条* 属性面板 = dynamic_cast<C_状态条*>(self);
	属性面板->m_背景绘制.m_属性 = f_vg_gen属性(画布);
	S_凸边图元 图元{};
	图元.属性 = f_vg_get属性(画布, 属性面板->m_背景绘制.m_属性);
	属性面板->m_背景绘制.f_Draw(画布, 图元, E_笔刷类型::e_单色填充);
}

static void on_状态条变换修改(C_Widget* self) {
	C_状态条* 属性面板 = dynamic_cast<C_状态条*>(self);

	属性面板->m_背景绘制.f_alloc(1);

	mat3X2 mat;
	mat.row0 = {};
	mat.row1 = self->m_Size;
	mat.row2 = {};
	属性面板->m_背景绘制.f_set单色填充(0, mat, S_UI主题::uic_深灰, S_Widget预设图元::m_矩形);

}

C_状态条::C_状态条(S_UI创建环境& ctx) :C_Widget(&ctx) {
	
	f_setSize({ g状态栏高度, g状态栏高度+3 });

	mf_布局Fun = on_状态栏布局;
	mf_DrawFun = on_状态栏Draw;
	mf_变换修改 = on_状态条变换修改;
	
	m_View = new C_属性栏视口(ctx);
	m_View->f_切换方向(E_方向::e_横向);

	f_添加子组件(m_View);

}

void C_状态条::f_构建属性部件(std::vector<S_Props>& newProp, C_状态条* 分身) {
	m_View->f_构建属性部件(newProp);
	
	if (分身 && 分身 != this && 分身->m_View) {
		uint32 num = m_View->m_枚举使用计数;
		for (uint32 i = 0; i < num; ++i) {
			//f_ui_映射枚举组件绘制颜色(分身->m_View->m_枚举部件[i], m_View->m_枚举部件[i]);
		}
	}

	m_绘制属性更新 = true;
	m_GPU参数重置 = true;

}

S_Props& C_状态条::f_getProp(uint16 offset) {
	return m_View->m_属性[offset];
}





void f_属性栏_刷新属性绘制() {
	for (auto& e : g_当前所有属性栏) {
		for (auto& p : e->m_属性) {
			p.m_UI->m_部件->m_绘制属性更新 = true;

			switch (p.m_Type)
			{
				case E_值类型::e_Type_F32:
				case E_值类型::e_Type_I8:
				case E_值类型::e_Type_I16:
				case E_值类型::e_Type_I32:
				case E_值类型::e_Type_I64:
				case E_值类型::e_Type_UI8:
				case E_值类型::e_Type_UI16:
				case E_值类型::e_Type_UI32:
				case E_值类型::e_Type_UI64:
					f_ui_刷新数值编辑框绘制(p.m_UI->m_部件);
					break;

				case E_值类型::e_Type_Vec2:
				case E_值类型::e_Type_Vec3:
				case E_值类型::e_Type_Vec4:
				case E_值类型::e_Type_iVec2:
				case E_值类型::e_Type_iVec3:
				case E_值类型::e_Type_iVec4:
				case E_值类型::e_Type_Vec2_1D:
				case E_值类型::e_Type_Vec3_1D:
				case E_值类型::e_Type_Vec4_1D:
				case E_值类型::e_Type_iVec2_1D:
				case E_值类型::e_Type_iVec3_1D:
				//case E_值类型::e_Type_iVec4_1D:
					f_ui_刷新vec编辑框文本绘制(p.m_UI->m_部件);
					break;

				case E_值类型::e_Type_LineText:
					break;
				default:
					break;
			}
		}
		//e->m_绘制属性更新 = true;
	}
}


